Pyc字节码分析 2

字数统计: 3.9k字   |   阅读时长≈ 18分

基于上篇博客对pyc结构的了解，继续看汇编指令。

Pyc字节码分析 2

汇编指令集

https://docs.python.org/3/library/dis.html 讲述py3的dis模块，顺带了讲了一下指令含义。

python的指令集属于是代代更新的。每次都会多几个新指令，同时把一些不常用的旧指令又给抛弃掉。

先从python36开始，然后每个版本的删增都贴上来。

python36

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
// python36
1   POP_TOP
2   ROT_TWO
3   ROT_THREE
4   DUP_TOP
5   DUP_TOP_TWO
9   NOP
10  UNARY_POSITIVE
11  UNARY_NEGATIVE
12  UNARY_NOT
15  UNARY_INVERT
16  BINARY_MATRIX_MULTIPLY
17  INPLACE_MATRIX_MULTIPLY
19  BINARY_POWER
20  BINARY_MULTIPLY
22  BINARY_MODULO
23  BINARY_ADD
24  BINARY_SUBTRACT
25  BINARY_SUBSCR
26  BINARY_FLOOR_DIVIDE
27  BINARY_TRUE_DIVIDE
28  INPLACE_FLOOR_DIVIDE
29  INPLACE_TRUE_DIVIDE
50  GET_AITER
51  GET_ANEXT
52  BEFORE_ASYNC_WITH
55  INPLACE_ADD
56  INPLACE_SUBTRACT
57  INPLACE_MULTIPLY
59  INPLACE_MODULO
60  STORE_SUBSCR
61  DELETE_SUBSCR
62  BINARY_LSHIFT
63  BINARY_RSHIFT
64  BINARY_AND
65  BINARY_XOR
66  BINARY_OR
67  INPLACE_POWER
68  GET_ITER
69  GET_YIELD_FROM_ITER
70  PRINT_EXPR
71  LOAD_BUILD_CLASS
72  YIELD_FROM
73  GET_AWAITABLE
75  INPLACE_LSHIFT
76  INPLACE_RSHIFT
77  INPLACE_AND
78  INPLACE_XOR
79  INPLACE_OR
80  BREAK_LOOP
81  WITH_CLEANUP_START
82  WITH_CLEANUP_FINISH
83  RETURN_VALUE
84  IMPORT_STAR
85  SETUP_ANNOTATIONS
86  YIELD_VALUE
87  POP_BLOCK
88  END_FINALLY
89  POP_EXCEPT
90  STORE_NAME_A
91  DELETE_NAME_A
92  UNPACK_SEQUENCE_A
93  FOR_ITER_A
94  UNPACK_EX_A
95  STORE_ATTR_A
96  DELETE_ATTR_A
97  STORE_GLOBAL_A
98  DELETE_GLOBAL_A
100 LOAD_CONST_A
101 LOAD_NAME_A
102 BUILD_TUPLE_A
103 BUILD_LIST_A
104 BUILD_SET_A
105 BUILD_MAP_A
106 LOAD_ATTR_A
107 COMPARE_OP_A
108 IMPORT_NAME_A
109 IMPORT_FROM_A
110 JUMP_FORWARD_A
111 JUMP_IF_FALSE_OR_POP_A
112 JUMP_IF_TRUE_OR_POP_A
113 JUMP_ABSOLUTE_A
114 POP_JUMP_IF_FALSE_A
115 POP_JUMP_IF_TRUE_A
116 LOAD_GLOBAL_A
119 CONTINUE_LOOP_A
120 SETUP_LOOP_A
121 SETUP_EXCEPT_A
122 SETUP_FINALLY_A
124 LOAD_FAST_A
125 STORE_FAST_A
126 DELETE_FAST_A
127 STORE_ANNOTATION_A
130 RAISE_VARARGS_A
131 CALL_FUNCTION_A
132 MAKE_FUNCTION_A
133 BUILD_SLICE_A
135 LOAD_CLOSURE_A
136 LOAD_DEREF_A
137 STORE_DEREF_A
138 DELETE_DEREF_A
141 CALL_FUNCTION_KW_A
142 CALL_FUNCTION_EX_A
143 SETUP_WITH_A
144 EXTENDED_ARG_A
145 LIST_APPEND_A
146 SET_ADD_A
147 MAP_ADD_A
148 LOAD_CLASSDEREF_A
149 BUILD_LIST_UNPACK_A
150 BUILD_MAP_UNPACK_A
151 BUILD_MAP_UNPACK_WITH_CALL_A
152 BUILD_TUPLE_UNPACK_A
153 BUILD_SET_UNPACK_A
154 SETUP_ASYNC_WITH_A
155 FORMAT_VALUE_A
156 BUILD_CONST_KEY_MAP_A
157 BUILD_STRING_A
158 BUILD_TUPLE_UNPACK_WITH_CALL_A
    
enum cmp_op {
    PyCmp_LT=Py_LT, 
    PyCmp_LE=Py_LE, 
    PyCmp_EQ=Py_EQ, 
    PyCmp_NE=Py_NE,
    PyCmp_GT=Py_GT, 
    PyCmp_GE=Py_GE, 
    PyCmp_IN, 
    PyCmp_NOT_IN,
    PyCmp_IS, 
    PyCmp_IS_NOT, 
    PyCmp_EXC_MATCH, 
    PyCmp_BAD
};

汇编指令可在Include/opcode.h中找到。也可以在pycdc主文件夹下的bytes文件夹中找到一大堆.map文件，这里有各个版本的指令。

python37

1
2
3
4
比对python36：
删除 127 STORE_ANNOTATION_A
新增 160 LOAD_METHOD_A
新增 161 CALL_METHOD_A

python38

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
diff python_37.map python_38.map

新增 6   ROT_FOUR

新增 53  BEGIN_FINALLY
新增 54  END_ASYNC_FOR

删除 80  BREAK_LOOP

删除 119 CONTINUE_LOOP_A
删除 120 SETUP_LOOP_A
删除 121 SETUP_EXCEPT_A

新增 162 CALL_FINALLY_A
新增 163 POP_FINALLY_A

python39

<是删除，>是新增

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
diff python_38.map python_39.map
23a24,25
> 48  RERAISE
> 49  WITH_EXCEPT_START
27d28
< 53  BEGIN_FINALLY
46a48
> 74  LOAD_ASSERTION_ERROR
52,53c54
< 81  WITH_CLEANUP_START
< 82  WITH_CLEANUP_FINISH
---
> 82  LIST_TO_TUPLE
59d59
< 88  END_FINALLY
86a87,89
> 117 IS_OP_A
> 118 CONTAINS_OP_A
> 121 JUMP_IF_NOT_EXC_MATCH_A
107,111d109
< 149 BUILD_LIST_UNPACK_A
< 150 BUILD_MAP_UNPACK_A
< 151 BUILD_MAP_UNPACK_WITH_CALL_A
< 152 BUILD_TUPLE_UNPACK_A
< 153 BUILD_SET_UNPACK_A
116d113
< 158 BUILD_TUPLE_UNPACK_WITH_CALL_A
119,120c116,119
< 162 CALL_FINALLY_A
< 163 POP_FINALLY_A
---
> 162 LIST_EXTEND_A
> 163 SET_UPDATE_A
> 164 DICT_MERGE_A
> 165 DICT_UPDATE_A

python310

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
diff python_39.map python_310.map
24c24,28
< 48  RERAISE
---
> 30  GET_LEN
> 31  MATCH_MAPPING
> 32  MATCH_SEQUENCE
> 33  MATCH_KEYS
> 34  COPY_DICT_WITHOUT_KEYS
69a74
> 99  ROT_N_A
88a94
> 119 RERAISE_A
93a100
> 129 GEN_START_A
109a117
> 152 MATCH_CLASS_A

这些指令是真的多。

有参指令

PYC文件格式分析 (kdr2.com)

文章较老，格式是py27的，有参指令的规则似乎py3已经变化了。

1
2
3
// Include/opcode.h
#define HAVE_ARGUMENT 90
#define HAS_ARG(op) ((op) >= HAVE_ARGUMENT)

即大于等于90的指令都是有参数的。

pyc文件 - CTF Wiki (ctf-wiki.org)

python3.6 以上参数永远占 1 字节（包括指令本身那就是一共占2个字节）， 如果指令不带参数的话则以0x00代替， 在运行过程中被解释器忽略， 也是 Stegosaurus（一种.pyc文件隐写工具）的技术原理；

而低于 python3.5 的版本中指令不带参数的话却没有0x00填充。

老版本的python27则是一个指令占用1或3个字节。1就是无参数，3则是有参数，参数占2字节，且第二个一定是0x00。

举例

1
2
3
4
5
6
7
# py3.7.9
import dis
dis.dis(b'\x64\x00')

"""
           0 LOAD_CONST               0 (0)
"""

Python虚拟机简介

原本打算自己写点的，但是网上查到了很多分析CPython解释器的文章，所以也就不扯了。精简一下写一下重要的核心架构。

https://nanguage.gitbook.io/inside-python-vm-cn/1.-jian-jie

https://zhuanlan.zhihu.com/p/375323851

https://zhuanlan.zhihu.com/p/375323851

Python虚拟机详解_G1011的博客-CSDN博客_python虚拟机

《深度剖析CPython解释器》24. Python运行时环境的初始化、源码分析Python解释器在启动时都做了哪些事情？ - 古明地盆 - 博客园 (cnblogs.com)

  1. .pyc文件是PyCodeObject在磁盘上的表现形式，其中包含了字节码指令以及程序的所有静态信息
  2. 执行时的动态环境则由PyFrameObject承担
  3. PyInterpreterState模拟进程
  4. PyThreadState模拟线程
  5. 位于Python/ceval.c的PyEval_EvalFrameEx()函数是核心执行函数。

PyFrameObject

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
// Include/frameobject.h
typedef struct {
    int b_type;                 /* what kind of block this is */
    int b_handler;              /* where to jump to find handler */
    int b_level;                /* value stack level to pop to */
} PyTryBlock;

typedef struct _frame {
    PyObject_VAR_HEAD           // 运行时栈帧大小不确定，所以加"VAR"表示变量
    struct _frame *f_back;      //执行环境链上的前一个frame，很多个PyFrameObject连接起来形成执行环境链表  
    PyCodeObject *f_code;       // PyCodeObject 对象，这个frame就是这个PyCodeObject对象的上下文环境  
    PyObject *f_builtins;       // builtin命名空间，PyDictObject
    PyObject *f_globals;        // globals命名空间，PyDictObject
    PyObject *f_locals;         // 局部变量的符号表
    PyObject **f_valuestack;    // 栈底指针（指向最后一个局部变量的后面）
    
    /* Next free slot in f_valuestack.  Frame creation sets to f_valuestack.
       Frame evaluation usually NULLs it, but a frame that yields sets it
       to the current stack top. */
    PyObject **f_stacktop;      // 栈顶位置
    PyObject *f_trace;          /* Trace function */
    char f_trace_lines;         /* Emit per-line trace events? */
    char f_trace_opcodes;       /* Emit per-opcode trace events? */

    /* Borrowed reference to a generator, or NULL */
    PyObject *f_gen;

    //上一条字节码指令在f_code中的偏移位置  
    int f_lasti;                /* Last instruction if called */
    /* Call PyFrame_GetLineNumber() instead of reading this field
       directly.  As of 2.3 f_lineno is only valid when tracing is
       active (i.e. when f_trace is set).  At other times we use
       PyCode_Addr2Line to calculate the line from the current
       bytecode index. */
    // 当前字节码对应的源代码行  
    int f_lineno;               /* Current line number */
    int f_iblock;               /* index in f_blockstack */
    char f_executing;           /* whether the frame is still executing */
    PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
    
    //动态内存，维护(局部变量+cell对象集合+free对象集合+运行时栈)所需要的空间  
    PyObject *f_localsplus[1];  /* locals+stack, dynamically sized */
} PyFrameObject;

每一个 PyFrameObject对象都维护了一个 PyCodeObject对象，这表明每一个 PyFrameObject中的动态内存空间对象都和源代码中的一段代码相对应。

虚拟机简化结构

根据上面的栈帧结构，简化一下体系。

未经实际代码审计考证，但是能便于理解，且与实际相差不大。

Python虚拟机的核心就是一个栈，因为这是一个栈式虚拟机。实际上很多支持多架构的编程语言的虚拟机都是基于虚拟栈的，这样能够简化虚拟汇编指令的复杂度，也能方便移植。

同时我们也需要其他的一些东西，比如一些全局变量，或者一些必要的默认方法函数，比如上文所提f_globals或f_builtins都是字典对象，里面维护了函数和全局变量。

再有的就是PyCodeObject里面自带的一些信息，比如**co_names和co_consts**。

当然还有自己的局部变量。**co_nlocals显示局部变量（函数栈上的）的个数，co_varnames**则存储局部变量名。详见上个博客。

与指令集的关系

举几个常见指令

LOAD_CONST会将co_consts中的元素加载进栈

LOAD_NAME会将co_names中的字符串进栈

STORE_NAME会弹出栈顶元素，然后和co_names顶部元素相对应。相当于一个赋值操作。

1
2
LOAD_CONST "Hello"
STORE_NAME "s"

就相当于s = "Hello"。

LOAD_FAST就是加载局部变量进入栈中。

示例代码

举个例子

Py文件

基于上次的继续：

1
2
3
4
5
6
7
# test.py
s = "Hello"

def func(a, b=3, *args):
	c = 114514
	print(a, b)
	print(args)

Pyc文件

以及手动排版过的二进制代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
42 0d 0d 0a 	// 版本魔数
00 00 00 00 	// 位域（暂时没用）
49 a6 04 62 	// 时间戳
5b 00 00 00		// 文件大小

// ===============主PyCodeObject===================

e3 				// TYPE_CODE | FLAG_REF 0
00 00 00 00 	// co_argcount
00 00 00 00 	// co_kwonlyargcount
00 00 00 00 	// co_nlocals
03 00 00 00 	// co_stacksize
40 00 00 00 	// co_flags（CO_NOFREE）

// co_code(作为TYPE_STRING存在)
73              // TYPE_STRING，字符串对象（其实通常是字节码对象）
12 00 00 00 	// 长度12
64 00 5a 00 64 05 64 02 64 03 84 01 5a 01 64 04 53 00 

// co_consts
29			   // TYPE_SMALLTUPLE，PyTupleObject : PySequenceObject
06			   // size
	// value[0]
	5a			   // TYPE_SHORT_ASCII_INTERNED = 'Z',
	05			   // length
	48 65 6c 6c 6f 
	// value[1]
	e9 			   // TYPE_INT'i' | FLAG_REF 1
	03 00 00 00     // 4字节int
	// value[2]
	63			   // TYPE_CODE
	02 00 00 00	    // co_argcount
	00 00 00 00     // co_kwonlyargcount
	04 00 00 00     // co_nlocals
	03 00 00 00     // co_stacksize
	47 00 00 00     // co_flags (NOFREE | VARARGS | NEWLOCALS | OPTIMIZED)
        // co_code
        73              // TYPE_STRING
        1a 00 00 00     // 长度
        64 01 7d 03 74 00 7c 00 7c 01 83 02 01 00 74 00 7c 02 83 01 01 00 64 00 53 00 
        // co_consts
        29			   // TYPE_SMALLTUPLE
        02			   // size
        	// value[0]
   		    4e		   // TYPE_NONE = 'N',
   		    // value[1]
   		    69		   // TYPE_INT
   		    52 bf 01 00 // 114514
        // co_names
        29              // TYPE_SMALLTUPLE
        01              // size
        	da              // TYPE_SHORT_ASCII_INTERNED | FLAG_REF 2
        	05              // length
        	70 72 69 6e 74 // 'print'
        	
        // co_varnames
        29              // TYPE_SMALLTUPLE
        04              // size 
        	// value[0]
        	da              // TYPE_SHORT_ASCII_INTERNED | FLAG_REF  3
        	01              // length 
        	61              // 'a' 
        	// value[1]
        	da              // TYPE_SHORT_ASCII_INTERNED | FLAG_REF  4
        	01              // length 
        	62              // 'b'
        	// value[2]
        	da              // TYPE_SHORT_ASCII_INTERNED | FLAG_REF  5
        	04              // length 
        	61 72 67 73	    // 'args'
        	// value[3]
        	da              // TYPE_SHORT_ASCII_INTERNED | FLAG_REF  6
        	01              // length 
        	63              // 'c'
        // co_freevars
        a9              // TYPE_SMALLTUPLE | FLAG_REF 	7
        00 
        // co_cellvars
        72              // TYPE_OBREF = 'r',
        07 00 00 00 	// 指向上面的co_freevars，是空的。
        // co_filename
        fa              // TYPE_SHORT_ASCII | FLAG_REF 8
        09 
        2e 5c 74 65 73 74 2e 70 79 	// r".\test.py"
        // co_name
        da              // TYPE_SHORT_ASCII_INTERNED | FLAG_REF 9
        04              // length 
        66 75 6e 63     // "func"
        // co_firstlineno
        04 00 00 00     // 4
        // co_lnotab
        73              // TYPE_STRING 
        06 00 00 00 
        00 01 04 01 0a 01 
	// value[3] -> "func"
	72 			   // TYPE_OBREF = 'r'
	09 00 00 00     // index
	// value[4]
	4e 			   // TYPE_NONE = 'N'
	// value[5]
	29 			   // TYPE_SMALLTUPLE
	01 			   // size
	    // value[0] -> 3
        72	       // TYPE_OBREF = 'r'
        01 00 00 00 	// index
// co_names
29         // TYPE_SMALLTUPLE
02         // size 
    // value[0]
    da    // TYPE_SHORT_ASCII_INTERNED | FLAG_REF 10 
    01    // length
    73    // 's'
    // value[1] -> "func"
    72 			   // TYPE_OBREF = 'r' 
    09 00 00 00     // index = 9 
// co_varnames
72 			       // TYPE_OBREF = 'r'
07 00 00 00         // index
// co_freevars -> None
72 			       // TYPE_OBREF = 'r' 
07 00 00 00         // index 
// co_cellvars -> None
72 			       // TYPE_OBREF = 'r' 
07 00 00 00         // index 
// co_filename -> r".\test.py"
72 			       // TYPE_OBREF = 'r'
08 00 00 00         // index 
// co_name
da              // TYPE_SHORT_ASCII_INTERNED | FLAG_REF  
08              // length
3c 6d 6f 64 75 6c 65 3e // "<module>"
// co_firstlineno
02 00 00 00
// co_lnotab
73              // TYPE_STRING 
02 00 00 00 
04 02

下次可以考虑一下写个脚本打印了。

必要前置数据

待会汇编指令要用上的东西我们先整理出来。

文件名是test.cpython-37.pyc，于是写个脚本把它读取出来。

1
2
3
4
5
6
7
import marshal, dis
f = open('test.cpython-37.pyc', 'rb')
f.read(4)
f.read(4)
f.read(4)
f.read(4)
b = marshal.load(f)

得到一个名为b的PyCodeObject。

如上文所述，我们需要前置数据的是

  1. co_names
  2. co_consts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> b.co_consts
('Hello', 3, <code object func at 0x0000023F92EF2DB0, file ".\test.py", line 4>, 'func', None, (3,))
>>> b.co_consts[0]
'Hello'
>>> b.co_consts[1]
3
>>> b.co_consts[2]
<code object func at 0x0000023F92EF2DB0, file ".\test.py", line 4>
>>> b.co_consts[3]
'func'
>>> b.co_consts[4]
>>> b.co_consts[5]
(3,)

>>> b.co_names
('s', 'func')

反汇编co_code代码

然后我们使用dis模块反汇编出代码来：

1
2
3
4
5
6
7
8
9
10
>>> dis.dis(b.co_code)
          0 LOAD_CONST               0 (0)
          2 STORE_NAME               0 (0)
          4 LOAD_CONST               5 (5)	// (3,)
          6 LOAD_CONST               2 (2)  // func code object
          8 LOAD_CONST               3 (3)  // "func"
         10 MAKE_FUNCTION            1      // a tuple of default values for positional-only and positional-or-keyword parameters in positional order
         12 STORE_NAME               1 (1)	// func = MAKE_FUNCTION(...)
         14 LOAD_CONST               4 (4)  // None
         16 RETURN_VALUE                    // 返回None

LOAD_CONST 0加载了co_consts的第一个元素，即"Hello"

然后STORE_NAME 0把栈顶元素"Hello"弹出来存到了co_names对应的第一个元素，也就是s

相当于s = "Hello"

后面的同理

这样我们就知道大致的意思了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
"""
0 LOAD_CONST               0 (0)
2 STORE_NAME               0 (0)
"""
s = "Hello"
"""
4 LOAD_CONST               5 (5)	// (3,)
6 LOAD_CONST               2 (2)  // func code object
8 LOAD_CONST               3 (3)  // "func"
10 MAKE_FUNCTION            1      // a tuple of default values for positional-only and positional-or-keyword parameters in positional order
12 STORE_NAME               1 (1)	// func = MAKE_FUNCTION(...)
"""
# 这一串是伪代码
func = MAKE_FUNCTION(<func code object>, position_or_keyword_only_args=(3,))

# 伪代码
return None

上面反汇编的是整个模块的逻辑。

然后再反汇编一下func函数的逻辑

1
2
3
4
5
6
7
# b.co_consts[2]就是func对象
>>> b.co_consts[2].co_names
('print',)
>>> b.co_consts[2].co_varnames
('a', 'b', 'args', 'c')
>>> b.co_consts[2].co_consts
(None, 114514)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
>>> dis.dis(b.co_consts[2].co_code)
          # c = 114514
          0 LOAD_CONST               1 (1)	# push 114514
          2 STORE_FAST               3 (3)  # c = 114514
          # print(a, b)
          4 LOAD_GLOBAL              0 (0)  # push global_obj co_names[0] == "print"
          6 LOAD_FAST                0 (0)  # push a
          8 LOAD_FAST                1 (1)  # push b --> 这个在最顶端
         10 CALL_FUNCTION            2      # 其中最右边的参数在最顶端，即从左往右push；区别于C式栈，从右往左push
         12 POP_TOP                         # 不要返回值，直接弹掉
          # print(args)
         14 LOAD_GLOBAL              0 (0)  # push global_obj co_names[0] == "print"
         16 LOAD_FAST                2 (2)  # push args
         18 CALL_FUNCTION            1
         20 POP_TOP
        
          # return None
         22 LOAD_CONST               0 (0)  # push None
         24 RETURN_VALUE

补充

关于co_freevars和co_cellvars

补充上次博客没仔细讲的点。这两个成员是用于Python闭包的。

PYC文件格式分析 (kdr2.com)

1
2
3
4
5
def outter(o1,o2):
    fc1=o1+o2
    fc2=o1*o2
    def inner(i):
        return (fc1+fc2)*i
  • 对于 outter 函数来说,他的局部变量 fc1 和 fc2 被它内部嵌套的函数所引用,则 fc1 和 fc2 变成它的cellvars而不是局部变量 varnames
  • 对于 inner 函数，fc1和fc2既不是局部变量也不是全局变量，他引用自外层函数，则 fc1 和 fc2 是 inner 的 freevars

关于MAKE_FUNCTION汇编指令

上文示例用到了，但是没解释具体咋用。这里强调一下。

1
2
3
4
5
6
7
8
9
10
11
// https://stackoverflow.com/questions/54877888/python-3-7-bytecode-make-function-how-to-interpret-such-disassembled-function-d
// https://docs.python.org/3/library/dis.html
MAKE_FUNCTION(argc)
Pushes a new function object on the stack. From bottom to top, the consumed stack must consist of values if the argument carries a specified flag value:

0x01   a tuple of default values for positional-only and positional-or-keyword parameters in positional order
0x02   a dictionary of keyword-only parameters’ default values
0x04   an annotation dictionary
0x08   a tuple containing cells for free variables, making a closure
the code associated with the function (at TOS1)
the qualified name of the function (at TOS)

关于其他指令

https://docs.python.org/zh-cn/3/library/dis.html

官方文档其实都有解释，且支持中文。

其他

逆向技巧

上一次尝试逆向python3.10的.pyc文件时，我是对着题目的反汇编文本，写出猜出来的高级语言代码，然后再用dis模块去反汇编它，得到的反汇编文本再和题目比对，一致就是猜对了。不完全一致，则稍微修改一下，反复尝试，直到一致。

待解决

关于pyinstaller打包时加密

随便乱翻文章的时候发现的问题。

https://z.itpub.net/article/detail/F9A280FCEFD651D8ED7E06DA707747F5

在结尾处，作者说能够传入--key参数传入密码进行加密。

1
pip install tinyaes
1
pyinstaller -Fw --icon=h.ico auto_organize_gui.py --add-data="h.ico;/" --key 123456

由于是本地加密，本地执行，所以按理文件会在执行的时候再次被解密，或者可能会在某个时刻泄露密钥。所以可以尝试逆向工程一番，或者通过审计源码，了解过程。

自动解析一般pyc文件结构的小脚本

上面是纯手撸的，有点蠢。有空写个自动化解析的。

pyc混淆

逆python–pyc文件结构及pyc混淆基础_招财猫的小叮当的博客-CSDN博客

想法挺好的，即网上大部分反汇编器都是线性扫描的，比如pycdas，但是实际上Python解释器的执行是一个字节一个字节顺着执行流的，所以可以通过设计一些永不可达分支，在上面添加垃圾无效指令，从而实现反反汇编。

pyc汇编举例

像上次分析Cython一样，举一些常见例子来分析一下，总结一下大致结构。

但是由于这个难度比Cython简单很多很多，所以一篇博客稍微谈谈足矣。

pyc汇编指令大全

官网上有，但是没有具体例子。我准备基于官网上的简介再举一些例子，强化理解。

pyc高版本结构区别

python39和python310都是无法反编译的。主要是新增的指令；但在我的印象中，头文件似乎有一些区别。我稍微尝试一下吧。

参考

python 字节码死磕 - 大步向前blue - 博客园 (cnblogs.com)

https://nanguage.gitbook.io/inside-python-vm-cn/2.-the-view-from-30-000ft

https://z.itpub.net/article/detail/F9A280FCEFD651D8ED7E06DA707747F5

https://docs.python.org/zh-cn/3/library/dis.html

PYC文件格式分析 (kdr2.com)

https://nanguage.gitbook.io/inside-python-vm-cn/1.-jian-jie

https://zhuanlan.zhihu.com/p/375323851

https://zhuanlan.zhihu.com/p/375323851

Python虚拟机详解_G1011的博客-CSDN博客_python虚拟机

《深度剖析CPython解释器》24. Python运行时环境的初始化、源码分析Python解释器在启动时都做了哪些事情？ - 古明地盆 - 博客园 (cnblogs.com)

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

A junior undergraduate
studying in the college of cyber science and engineering
in Sichuan University
in Sichuan , China.
Pronouns:He/him.
A core member of 0x401 CTF team
majorly focus on Reverse Engineering chanllenges.